#include "homework.h"

#include <iostream>

using namespace std;

void My_Array::init_my_array()
{
    /*
    申请存储 int 类型数据的数组空间
    */
    array_data = new int[DEFAULT_CAPACITY];
    memset(array_data, 0, DEFAULT_CAPACITY);

    /*
    capacity 对应底层数组的容量，赋值为默认容量 DEFAULT_CAPACITY
    */
    capacity = DEFAULT_CAPACITY;
    /*
    当前 size 有效元素个数为 0
    */
    size = 0;
}

void My_Array::add_element(int ele)
{
    array_data[size++] = ele;
}

void My_Array::show()
{
    // 当前数组有效元素为 0 ，没有元素
    if (0 == size)
    {
        cout << "[]" << endl;
    }

    cout << '[';

    for (int i = 0; i < size - 1; i++)
    {
        cout << array_data[i] << ", ";
    }

    cout << array_data[ size - 1] << ']' << endl;
}

int My_Array::min_value()
{
    /*
    结构体中的成员函数可以直接使用结构体内部的成员变量
        array_data 结构体中的数据数组
        size 是当前数组的有效元素个数
    */
    int min_value = array_data[0];

    for (int i = 1; i < size; i++)
    {
        if (array_data[i] < min_value)
        {
            min_value = array_data[i];
        }
    }

    return min_value;
}

int My_Array::max_value()
{
    /*
    结构体中的成员函数可以直接使用结构体内部的成员变量
        array_data 结构体中的数据数组
        size 是当前数组的有效元素个数
    */
    int max_value = array_data[0];

    for (int i = 1; i < size; i++)
    {
        if (array_data[i] > max_value)
        {
            max_value = array_data[i];
        }
    }

    return max_value;
}

double My_Array::avg_value()
{
    int total_value = 0;

    for (int i = 0; i < size; i++)
    {
        total_value += array_data[i];
    }

    return total_value / (size * 1.0);
}

int My_Array::find(int value)
{
    int index = -1;
    for (int i = 0; i <= size; i++)
    {
        if (array_data[i] == value)
        {
            index = i;
            break;
        }
    }

    return index;
}

int My_Array::rfind(int value)
{
    int index = -1;
    for (int i = size - 1; i >= 0; i--)
    {
        if (array_data[i] == value)
        {
            index = i;
            break;
        }
    }

    return index;
}

void My_Array::add_element(int index, int ele)
{
    int temp = 0;

    temp = array_data[index];

    for (int i = size - 1; i > index; i--)
    {
        array_data[i] = array_data[i - 1];
    }
    array_data[index] = ele;
}



int My_Array::remove(int index)
{
    int temp = array_data[index];

    for (int i = index; i < size - 1; i++)
    {
        array_data[i] = array_data[i + 1];
    }

    size--;

    return temp;
    
}

void My_Array::remove_all(int ele)
{
    int num = 0;
    for (int i = 0; i < size; i++)
    {
        if (ele != array_data[i])
        {
            array_data[num++] = array_data[i];
        }
    }
    size = num;
}

void My_Array::remove_all(int begin, int end)
{
    while (begin >= 0 && end <= size)
    {   
        array_data[begin + 1] = array_data[end + 1];
        begin++;
        end++;
    }

    size -= (end - begin);
}

void My_Array::replace(int index, int new_value)
{
    array_data[index] = new_value;
}

void My_Array::replace_all(int old_value, int new_value)
{
    for (int i = 0; i < size; i++)
    {
        if (old_value == array_data[i])
        {
            array_data[i] = new_value;
        }
    } 
}

void My_Array::reveser()
{
    int temp = 0;

    for (int i = 0; i < size / 2; i++)
    {
        temp = array_data[i];
        array_data[i] = array_data[size - i - 1];
        array_data[size - i - 1] = temp;
    }
} 

int My_Array::at(int index)
{
    return array_data[index];
}

void My_Array::sort_desc()
{
    for (int i = 0; i < size;i++)
    {
        int max = array_data[i];
        for (int j = i + 1; j < size; j++)
        {
            if (array_data[j] >= max)
            {
                max = array_data[j];
                array_data[j] = array_data[i];
                array_data[i] = max;
            }
        }
    }
}
   
void My_Array::sort_asc()
{
    for (int i = 0; i < size;i++)
    {
        int min = array_data[i];
        for (int j = i + 1; j < size; j++)
        {
            if (array_data[j] <= min)
            {
                min = array_data[j];
                array_data[j] = array_data[i];
                array_data[i] = min;
            }
        }
    }
}

void My_Array::add_all(My_Array &ma)
{
    for (int i = 0; i < ma.size; i++)
    {
        array_data[i + size] = ma.array_data[i];
    }

    size += ma.size;
}

void My_Array::add_all(int index, My_Array &ma)
{
    if (index >= 0 && index <= size)
    {
        for (int j = index + ma.size; j < capacity; j++)
        {
            array_data[j] = array_data[j - ma.size];
        }
        
        for (int i = 0; i < ma.size; i++)
        {
            array_data[i + index] = ma.array_data[i];
        }
        
        size += ma.size;
    }
    else
    {
        cout << "越界了 !" << endl;
    }
}

void My_Array::remove_all(My_Array &ma)
{
    int num = size;

    for (int i = 0; i < ma.size; i++)
    {
        for (int j = 0; j < size; j++)
        {
            if (array_data[j] == ma.array_data[i])
            {
                for (int k = j; k < size;k++)
                {
                    array_data[k] = array_data[k + 1];
                }
                num--;
                break;
            }
        }
    }
    size = num;
}

void My_Array::retain_all(My_Array &ma)
{
    int num = size;
    int status = 1;

    for (int i = 0; i < num; i++)
    {
        status = 1;
        for (int j = 0; j < ma.size; j++)
        {
            if (array_data[i] == ma.array_data[j])
            {
                status = 0;
                break;
            } 
        }
        if (status)
        {
            for (int k = i; k < num - 1;k++)
            {
                array_data[k] = array_data[k + 1];
            }
            num--;
            i--;
        }
    }
    size = num;
}

void My_Array::replace_all(int pos, int count, My_Array &ma)
{
    if (pos + count > size)
    {
        cout << "越界了哥们儿 ！！" << endl;
    }
    else
    {
        for (int i = pos; i <= count; i++)
        {
            array_data[pos + i] = ma.array_data[i];
        }
    }
}

My_Array &My_Array::sub_array(int pos, int count)
{
    // 创建一个新的 My_Array 对象
    My_Array *result = new My_Array();

    // 检查 pos 和 count 的合法性
    if (pos < 0 || pos >= size || count <= 0)
    {
        // 如果参数不合法，返回一个空的 My_Array
        result->size = 0;
        result->array_data = nullptr;
        return *result;
    }

    // 计算实际可以截取的元素个数
    int actual_count = (pos + count > size) ? (size - pos) : count;

    // 为新数组分配内存
    result->array_data = new int[actual_count];
    result->size = actual_count;

    // 复制数据到新数组
    for (int i = 0; i < actual_count; i++)
    {
        result->array_data[i] = array_data[pos + i];
    }

    // 返回新数组
    return *result;
}

void My_Array::destroy()
{
    delete[] array_data;
}
